
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class RestaurantAff extends JPanel{

	private static final long   serialVersionUID = 1L;  

	private JFrame frame;
	private Celule[][] restaurant;

	//Images
	private BufferedImage CaseVideJPG ;
	private BufferedImage SeparationJPG ;
	//Table
	private BufferedImage TableCuisineVideJPG;
	private BufferedImage[] TableCuisinePlatJPG = new BufferedImage[RestaurantEnv.PLATS_PAR_TABLE_CUISINE];
	private BufferedImage[] TableCuisineComandeJPG = new BufferedImage[RestaurantEnv.COMMANDES_PAR_CUISINIER];
	//Four
	private BufferedImage FourVideJPG;
	private BufferedImage[] FourPlatJPG = new BufferedImage[RestaurantEnv.PLATS_PAR_FOUR];
	//Agents
	private BufferedImage[] CuisinierJPG = new BufferedImage[RestaurantEnv.MAX_CUISINIERS];
	private BufferedImage[] ServeurJPG = new BufferedImage[RestaurantEnv.MAX_SERVEURS];
	//Tables Restaurant
	private BufferedImage TableVideNOJPG ;
	private BufferedImage TableVideSOJPG ;
	private BufferedImage TableVideNEJPG ;
	private BufferedImage TableVideSEJPG ;
	private BufferedImage[] TableNOPlatJPG = new BufferedImage[RestaurantEnv.PLATS_PAR_TABLE];
	private BufferedImage[] TableSOPlatJPG = new BufferedImage[RestaurantEnv.PLATS_PAR_TABLE];
	private BufferedImage[] TableNEPlatJPG = new BufferedImage[RestaurantEnv.PLATS_PAR_TABLE];
	private BufferedImage[] TableSEPlatJPG = new BufferedImage[RestaurantEnv.PLATS_PAR_TABLE];


	public RestaurantAff() {

		//Charge chaque image et guarde dans la memoire
		initialise_images();
		
		restaurant = new Celule[RestaurantEnv.TAILLE_DE_CUISINE_X][RestaurantEnv.TAILLE_DE_CUISINE_Y+RestaurantEnv.TAILLE_DE_RESTAURANT_Y];
		frame = new JFrame();
		frame.setSize(RestaurantEnv.TAILLE_DE_CUISINE_X*40,(RestaurantEnv.TAILLE_DE_CUISINE_Y+RestaurantEnv.TAILLE_DE_RESTAURANT_Y)*40);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setContentPane(this);
		setLayout(new GridLayout(RestaurantEnv.TAILLE_DE_CUISINE_Y+RestaurantEnv.TAILLE_DE_RESTAURANT_Y, RestaurantEnv.TAILLE_DE_CUISINE_X));

		//Rempli la cuisine
		initialise_cuisine();

		//Rempli le restaurant
		initialise_restaurant();		
		
		//fait apparaitre une ligne entre la cuisine et le restaurant:
		
		
		frame.setVisible(true); //fait apparaitre la grille

	}

	public synchronized void add_case_vide(int x, int y) {
		restaurant[x][y].paint(CaseVideJPG);
		restaurant[x][y].repaint();
	}

	public void add_cuisinier(int x, int y, int cuisinier_index, String nomCuisinier) {
		restaurant[x][y].paint(CuisinierJPG[cuisinier_index]);
		restaurant[x][y+1].nomCuisinier=nomCuisinier;
		restaurant[x][y+1].nb_etat=0;
		restaurant[x][y-1].nomCuisinier=nomCuisinier;
		restaurant[x][y-1].nb_etat=0;
		restaurant[x][y].repaint();
	}

	public synchronized void add_serveur(int x, int y, int serveur_index) {
		restaurant[x][y].paint(ServeurJPG[serveur_index]);
		restaurant[x][y].repaint();
	}		

	public void add_four_vide(int x, int y) {
		restaurant[x][y].paint(FourVideJPG);
		restaurant[x][y].repaint();
	}

	public void add_plat_au_four(String nomCuisinier) {
		int a;
		for (int i = 0; i<RestaurantEnv.TAILLE_DE_CUISINE_X-1;i++){
			if (restaurant[i][0].nomCuisinier.equals(nomCuisinier)){
				//System.out.println(restaurant[i][2].nomCuisinier + " EST egal a " +nomCuisinier);
				if (restaurant[i][0].nb_etat<0)restaurant[i][0].nb_etat=0;
				restaurant[i][0].nb_etat++;
				a = restaurant[i][0].nb_etat;
				System.out.println(String.valueOf(a)+ " plats au four de "+nomCuisinier);
				if (a>3){
					restaurant[i][0].paint(FourPlatJPG[3]);
					restaurant[i][0].repaint();
				}else {
					restaurant[i][0].paint(FourPlatJPG[a-1]);
					restaurant[i][0].repaint();
				}
			}//else System.out.println(restaurant[i][2].nomCuisinier + " n'est pas egal a " +nomCuisinier);
				//System.out.println("Essaye d'ajouter un plat du cuisinier "+nomCuisinier+ "mais on ne le connais pas!");
		}
	}

	public void remove_plat_au_four(String nomCuisinier) {
		int a;
		for (int i = 0; i<RestaurantEnv.TAILLE_DE_CUISINE_X-1;i++){
			if (restaurant[i][0].nomCuisinier.equals(nomCuisinier)){
				if (restaurant[i][0].nb_etat<0)restaurant[i][0].nb_etat=1;
				restaurant[i][0].nb_etat--;
				a = restaurant[i][0].nb_etat;
				System.out.println(String.valueOf(a)+ " plats au four de "+nomCuisinier +" (remove)");
				if (a>3){
					restaurant[i][0].paint(FourPlatJPG[3]);
					restaurant[i][0].repaint();
				}else if (a>0){
					restaurant[i][0].paint(FourPlatJPG[a-1]);
					restaurant[i][0].repaint();
				}else {
					restaurant[i][0].paint(FourVideJPG);
					restaurant[i][0].repaint();
				}
			}//else System.out.println("Essaye de remove un plat du cuisinier "+nomCuisinier+ " mais on ne le connais pas!");
		}
	
	}
	
	public void add_table_vide_cuisine(int x, int y) {
		restaurant[x][y].paint(TableCuisineVideJPG);
		restaurant[x][y].repaint();
	}
	
	public void add_plat_a_table_cuisine(String nomCuisinier) {
		int a;
		for (int i = 0; i<RestaurantEnv.TAILLE_DE_CUISINE_X-1;i++){
			if (restaurant[i][2].nomCuisinier.equals(nomCuisinier)){
				//System.out.println(restaurant[i][2].nomCuisinier + " EST egal a " +nomCuisinier);
				if (restaurant[i][2].nb_etat<0)restaurant[i][2].nb_etat=0;
				restaurant[i][2].nb_etat++;
				a = restaurant[i][2].nb_etat;
				if (a>3){
					restaurant[i][2].paint(TableCuisinePlatJPG[3]);
					restaurant[i][2].repaint();
				}else {
					restaurant[i][2].paint(TableCuisinePlatJPG[a-1]);
					restaurant[i][2].repaint();
				}
			}//else System.out.println(restaurant[i][2].nomCuisinier + " n'est pas egal a " +nomCuisinier);
				//System.out.println("Essaye d'ajouter un plat du cuisinier "+nomCuisinier+ "mais on ne le connais pas!");
		}
	}
	
	public void remove_plat_a_table_cuisine(String nomCuisinier) {

		int a;
		
		for (int i = 0; i<RestaurantEnv.TAILLE_DE_CUISINE_X-1;i++){
			if (restaurant[i][2].nomCuisinier.equals(nomCuisinier)){
				if (restaurant[i][2].nb_etat<0)restaurant[i][2].nb_etat=1;
				restaurant[i][2].nb_etat--;
				a = restaurant[i][2].nb_etat;
				//System.out.println(String.ValueOf(a));
				if (a>3){
					restaurant[i][2].paint(TableCuisinePlatJPG[3]);
					restaurant[i][2].repaint();
				}else if (a>0){
					restaurant[i][2].paint(TableCuisinePlatJPG[a-1]);
					restaurant[i][2].repaint();
				}else {
					restaurant[i][2].paint(TableCuisineVideJPG);
					restaurant[i][2].repaint();
				}
			}//else System.out.println("Essaye de remove un plat du cuisinier "+nomCuisinier+ " mais on ne le connais pas!");
		}
	}
	
	/*public void add_commande_a_table_cuisine(int x, int y, int nb_commande) {
		restaurant[x][y].paint(TableCuisineComandeJPG[nb_commande]);
		restaurant[x][y].repaint();
	}*/
	
	public void add_plat_a_table(int x, int y, int nb_plat) {
		int place_de_table = restaurant[x][y].case_etat;
		System.out.println("coin : "+place_de_table);
		switch (place_de_table){
		case RestaurantEnv.CASE_TABLE_NO:
			restaurant[x][y].paint(TableNOPlatJPG[nb_plat]);
			break;
		case RestaurantEnv.CASE_TABLE_SO:
			restaurant[x][y].paint(TableSOPlatJPG[nb_plat]);
			break;
		case RestaurantEnv.CASE_TABLE_NE:
			restaurant[x][y].paint(TableNEPlatJPG[nb_plat]);
			break;
		case RestaurantEnv.CASE_TABLE_SE:
			restaurant[x][y].paint(TableSEPlatJPG[nb_plat]);
			break;
		}
		restaurant[x][y].repaint();
	}

	public void add_table_vide(int x, int y) {
		int place_de_table = restaurant[x][y].case_etat;
		switch (place_de_table){
		case RestaurantEnv.CASE_TABLE_NO:
			restaurant[x][y].paint(TableVideNOJPG);
			break;
		case RestaurantEnv.CASE_TABLE_SO:
			restaurant[x][y].paint(TableVideSOJPG);
			break;
		case RestaurantEnv.CASE_TABLE_NE:
			restaurant[x][y].paint(TableVideNEJPG);
			break;
		case RestaurantEnv.CASE_TABLE_SE:
			restaurant[x][y].paint(TableVideSEJPG);
			break;
		}
		restaurant[x][y].repaint();
	}

	//Fonctions de initialisation
	void initialise_images(){
		try {
			int i;			
			
			CaseVideJPG 					= ImageIO.read(new File("Images/CaseVide.jpg"));
			SeparationJPG 					= ImageIO.read(new File("Images/Separation.jpg"));
			//Table de cuisine:
			TableCuisineVideJPG 			= ImageIO.read(new File("Images/TableCuisineVide.jpg"));
			for(i=0;i<RestaurantEnv.PLATS_PAR_TABLE_CUISINE;i++) {
				TableCuisinePlatJPG[i] 		= ImageIO.read(new File("Images/TableCuisinePlat"+ String.valueOf(i+1) + ".jpg"));
			}
			
			for(i=0;i<RestaurantEnv.COMMANDES_PAR_CUISINIER;i++) {
				TableCuisineComandeJPG[i] 	= ImageIO.read(new File("Images/TableCuisineComande"+ String.valueOf(i+1) + ".jpg"));
			}
			
			//Four
			FourVideJPG 					= ImageIO.read(new File("Images/FourVide.jpg"));				
			for(i=0;i<RestaurantEnv.PLATS_PAR_FOUR;i++) {
				FourPlatJPG[i] 				= ImageIO.read(new File("Images/FourPlat"+ String.valueOf(i+1) + ".jpg"));					
			}
			
			//Cuisiniers
			for(i=0;i<RestaurantEnv.MAX_CUISINIERS;i++) {
				CuisinierJPG[i] 			= ImageIO.read(new File("Images/Cuisinier"+ String.valueOf(i+1) + ".jpg"));
			}		
			
			//Serveurs
			for(i=0;i<RestaurantEnv.MAX_SERVEURS;i++) {
				ServeurJPG[i] 				= ImageIO.read(new File("Images/Serveur"+ String.valueOf(i+1) + ".jpg"));
			}					
			
			//Tables du Restaurant
			TableVideNOJPG					= ImageIO.read(new File("Images/TableVideNO.jpg"));
			TableVideSOJPG					= ImageIO.read(new File("Images/TableVideSO.jpg"));
			TableVideNEJPG					= ImageIO.read(new File("Images/TableVideNE.jpg"));
			TableVideSEJPG					= ImageIO.read(new File("Images/TableVideSE.jpg"));
			
			for(i=0;i<RestaurantEnv.PLATS_PAR_TABLE;i++) {
				TableNOPlatJPG[i] 			= ImageIO.read(new File("Images/TableNOPlat"+ String.valueOf(i+1) + ".jpg"));
				TableSOPlatJPG[i] 			= ImageIO.read(new File("Images/TableSOPlat"+ String.valueOf(i+1) + ".jpg"));
				TableNEPlatJPG[i] 			= ImageIO.read(new File("Images/TableNEPlat"+ String.valueOf(i+1) + ".jpg"));
				TableSEPlatJPG[i] 			= ImageIO.read(new File("Images/TableSEPlat"+ String.valueOf(i+1) + ".jpg"));
			}	
			System.out.println( "Images enregistrees" );
		} catch (IOException e) {
			// TODO Auto-generated catch block
			System.out.println( "Invalid Image! =>" + e.getMessage()  );
		}
	}

	void initialise_cuisine(){
		//Remplie la cuisine avec les images initialles
		for (int y = 0; y < RestaurantEnv.TAILLE_DE_CUISINE_Y; y++) {
			for (int x = 0; x < RestaurantEnv.TAILLE_DE_CUISINE_X; x++) {
				//Le contenue va dependre de la position
				int index = 0;
				
				if (y ==0) { //ligne des fours
					//Chaque four a "Vide_Gauche_Droite" et le derniere a "Vide" a droite.
					for (int j = 0; j < RestaurantEnv.MAX_FOURS; j++) {
						Celule c = new Celule(CaseVideJPG);
						restaurant[x][y] = c;
						c.case_etat=RestaurantEnv.CASE_VIDE;
						c.nb_etat = -1;
						add(c);

						Celule d = new Celule(FourVideJPG);
						restaurant[x+1][y] = d;
						d.case_etat=RestaurantEnv.CASE_FOUR;
						d.nb_etat = index;
						index++;
						add(d);

						Celule e = new Celule(FourVideJPG);
						restaurant[x+2][y] = e;
						e.case_etat=RestaurantEnv.CASE_FOUR;
						e.nb_etat = index;
						index++;
						add(e);

						x=x+3;
						
					}
					System.out.println( "derniere case des fours: x=" + String.valueOf(x)+ ", y=" + String.valueOf(y) );
					Celule c = new Celule(CaseVideJPG);
					restaurant[x][y] = c;
					c.case_etat=RestaurantEnv.CASE_VIDE;
					c.nb_etat = -1;
					add(c);


				} else if (y == RestaurantEnv.TAILLE_DE_CUISINE_Y-1) {//ligne de table de cuisine
					//Chaque table a "Vide_Gauche_Droite" et le derniere a "Vide" a droite.
					index=0;
					for (int j = 0; j < RestaurantEnv.MAX_TABLES_CUISINE; j++) {
						Celule c = new Celule(SeparationJPG);
						restaurant[x][y] = c;
						c.case_etat=RestaurantEnv.CASE_VIDE;
						c.nb_etat = -1;
						add(c);

						Celule d = new Celule(TableCuisineVideJPG);
						restaurant[x+1][y] = d;
						d.case_etat=RestaurantEnv.CASE_TABLE_CUISINE;
//						On midifie d.nb_etat : ca représente le nombre de plats sur la table
						d.nb_etat = 0;
						index++;
						add(d);

						Celule e = new Celule(TableCuisineVideJPG);
						restaurant[x+2][y] = e;
						e.case_etat=RestaurantEnv.CASE_TABLE_CUISINE;
						e.nb_etat = 0;
						index++;
						add(e);
						x=x+3;
					}
					System.out.println( " derniere case des tables: x=" + String.valueOf(x) + ", y=" + String.valueOf(y));
					Celule c = new Celule(SeparationJPG);
					c.case_etat=RestaurantEnv.CASE_VIDE;
					c.nb_etat = -1;
					restaurant[x][y] = c;
					add(c);

				} else {//ligne des cuisiniers et chef
					
					//Rempli avec CaseVide
					Celule c = new Celule(CaseVideJPG);
					restaurant[x][y] = c;
					c.case_etat=RestaurantEnv.CASE_VIDE;
					c.nb_etat = -1;
					add(c);
 

				}//Fin des If_Else de la cuisine
			}//Fin du For_X
		}//Fin du For_y
	}

	void initialise_restaurant(){
		
		
		//Remplie le restaurant avec les images initialles
		for (int y = RestaurantEnv.TAILLE_DE_CUISINE_Y; y < RestaurantEnv.TAILLE_DE_RESTAURANT_Y+RestaurantEnv.TAILLE_DE_CUISINE_Y; y++) { //ca commence en 4 jusqu'a fin+4
			for (int x = 0; x < RestaurantEnv.TAILLE_DE_RESTAURANT_X; x++) {
				//Le contenue va dependre de la position
				int index = 0;

				if ((y ==RestaurantEnv.TAILLE_DE_CUISINE_Y)||(y==RestaurantEnv.TAILLE_DE_CUISINE_Y+1)) { //ligne des serveurs
					//case vide
					Celule c = new Celule(CaseVideJPG);
					restaurant[x][y] = c;
					c.case_etat=RestaurantEnv.CASE_VIDE;
					c.nb_etat = -1;
					add(c);

				}else if (y > RestaurantEnv.TAILLE_DE_CUISINE_Y+1) {
					
					if ((y+RestaurantEnv.TAILLE_DE_CUISINE_Y)%2 == 0) { //ligne des tables - IMPAIR
						for (int j = 0; j < (int)(RestaurantEnv.MAX_TABLES/3 ); j++) {
							Celule c = new Celule(CaseVideJPG);
							restaurant[x][y] = c;
							c.case_etat=RestaurantEnv.CASE_VIDE;
							c.nb_etat = -1;
							add(c);

							Celule d = new Celule(TableVideNOJPG);
							restaurant[x+1][y] = d;
							d.case_etat=RestaurantEnv.CASE_TABLE_NO;
							d.nb_etat = index;
							index++;
							add(d);

							Celule e = new Celule(TableVideNEJPG);
							restaurant[x+2][y] = e;
							e.case_etat=RestaurantEnv.CASE_TABLE_NE;
							e.nb_etat = index;
							index++;
							add(e);

							x=x+3;
						}
						if (x==RestaurantEnv.TAILLE_DE_RESTAURANT_X-1){
							Celule c = new Celule(CaseVideJPG);
							restaurant[x][y] = c;
							c.case_etat=RestaurantEnv.CASE_VIDE;
							c.nb_etat = -1;
							add(c);
						}

					}else {//PAIRS

						for (int j = 0; j < (int)(RestaurantEnv.MAX_TABLES/3) ; j++) {
							Celule c = new Celule(CaseVideJPG);
							restaurant[x][y] = c;
							c.case_etat=RestaurantEnv.CASE_VIDE;
							c.nb_etat = -1;
							add(c);

							Celule d = new Celule(TableVideSOJPG);
							restaurant[x+1][y] = d;
							d.case_etat=RestaurantEnv.CASE_TABLE_SO;
							d.nb_etat = index;
							index++;
							add(d);

							Celule e = new Celule(TableVideSEJPG);
							restaurant[x+2][y] = e;
							e.case_etat=RestaurantEnv.CASE_TABLE_SE;
							e.nb_etat = index;
							index++;
							add(e);

							x=x+3;
						}

						if (x==RestaurantEnv.TAILLE_DE_RESTAURANT_X-1){
							
							Celule c = new Celule(CaseVideJPG);
							restaurant[x][y] = c;
							c.case_etat=RestaurantEnv.CASE_VIDE;
							c.nb_etat = -1;
							add(c);
						}
					}//fin else (impairs)

				}//Fin if y>4
			}//Fin for_x
		}//Fin for_y
	}//Fin initialise reataurant

}//Fin de RestaurantAffichage

//Chaque celule va avoir les metodes
class Celule extends JComponent {

	private static final long serialVersionUID = 1389567374668150895L;

	private BufferedImage image;
	public int case_etat = -1; //-1 = case vide
	public int nb_etat = -1; // Si etat = serveur, nb_etat= nb_serveur, si c'est table, nb_etat = nb_table, etc...
	public String nomCuisinier ="";
	
	public Celule(BufferedImage contenu_celule) {
		paint(contenu_celule); //Le constructeur recoi une image a mettre
	}

	@Override
	protected void paintComponent(Graphics g) {
		g.drawImage(image, 0, 0, getWidth(), getHeight(), null);
	}

	public void paint(BufferedImage contenu_celule){
		image = contenu_celule;
	}

}//Fin de la classe celule

